// pages/preview/preview.js
const api = require('../../utils/api');
const ImageProcessor = require('../../utils/imageProcessor');
const FileManager = require('../../utils/fileManager');
const placeholderIcon = require('../../images/placeholder');

Page({
  data: {
    docTitle: '未命名文档',
    scanImages: [], // 本地临时图片路径
    serverImages: [], // 服务器上的图片路径
    currentIndex: 0,
    saveOptions: false,
    isSaving: false,
    isUploading: false,
    uploadProgress: 0,
    useServerProcessing: true, // 是否使用服务器处理
    showServerStatus: true, // 是否显示服务器状态提示
    savedImages: [], // 已保存的图片路径，用于解决第二次保存问题
    validatedImages: [] // 验证过的有效图片路径
  },
  
  onLoad: function(options) {
    // 获取全局存储的扫描图片
    const app = getApp();
    const scanImages = app.globalData.scanImages;
    
    // 如果有传入的文档ID，则加载该文档
    if (options.docId) {
      this.loadDocument(options.docId);
    } else {
      // 否则使用当前扫描的图片
      this.setData({
        scanImages: scanImages,
        docTitle: app.globalData.currentDocTitle || '未命名文档'
      });
    }
    
    console.log('预览页面加载，图片数量:', this.data.scanImages.length);
    
    // 检查是否可以连接到服务器
    this.checkServerConnection();
  },
  
  // 检查服务器连接状态
  checkServerConnection: function() {
    const api = require('../../utils/api');
    
    api.checkServer().then(connected => {
      console.log('服务器状态:', connected ? '已连接' : '未连接');
      
      if (connected) {
        this.setData({ 
          useServerProcessing: true,
          showServerStatus: true,
          serverConnected: true,
          serverStatusText: '服务器已连接'
        });
      } else {
        this.setData({ 
          useServerProcessing: false,
          showServerStatus: true,
          serverConnected: false,
          serverStatusText: '服务器连接失败'
        });
        wx.showToast({
          title: '服务器连接失败，将使用本地处理',
          icon: 'none',
          duration: 2000
        });
      }
    });
  },
  
  // 隐藏服务器状态提示
  hideServerStatus: function() {
    this.setData({
      showServerStatus: false
    });
  },
  
  // 切换服务器处理模式
  toggleServerProcessing: function(e) {
    const useServer = e.detail.value;
    const api = require('../../utils/api');
    
    this.setData({
      useServerProcessing: useServer
    });
    
    if (useServer) {
      // 尝试连接服务器
      wx.showLoading({
        title: '正在连接服务器...',
      });
      
      api.checkServer().then(connected => {
        wx.hideLoading();
        console.log('服务器状态:', connected ? '已连接' : '未连接');
        
        if (connected) {
          this.setData({
            serverConnected: true,
            serverStatusText: '服务器已连接'
          });
          wx.showToast({
            title: '已连接到服务器',
            icon: 'success',
            duration: 1500
          });
        } else {
          this.setData({ 
            useServerProcessing: false,
            serverConnected: false,
            serverStatusText: '服务器连接失败'
          });
          wx.showModal({
            title: '连接失败',
            content: '无法连接到服务器，将使用本地处理模式。',
            showCancel: false
          });
        }
      });
    } else {
      wx.showToast({
        title: '已切换到本地处理模式',
        icon: 'success',
        duration: 1500
      });
    }
  },
  
  // 加载已保存的文档
  loadDocument: function(docId) {
    const recentDocs = wx.getStorageSync('recentDocs') || [];
    const doc = recentDocs.find(item => item.id === docId);
    
    if (doc) {
      this.setData({
        docTitle: doc.title,
        scanImages: doc.images
      });
    }
  },
  
  // 修改文档标题
  changeTitle: function() {
    wx.showModal({
      title: '修改文档名称',
      editable: true,
      placeholderText: '请输入文档名称',
      content: this.data.docTitle,
      success: (res) => {
        if (res.confirm && res.content) {
          this.setData({
            docTitle: res.content
          });
        }
      }
    });
  },
  
  // 滑动切换图片
  swiperChange: function(e) {
    this.setData({
      currentIndex: e.detail.current
    });
  },
  
  // 显示保存选项
  showSaveOptions: function() {
    this.setData({
      saveOptions: true
    });
  },
  
  // 隐藏保存选项
  hideSaveOptions: function() {
    this.setData({
      saveOptions: false
    });
  },
  
  // 阻止事件冒泡
  stopPropagation: function() {
    return;
  },
  
  // 上传图片到服务器
  uploadImages: function() {
    if (!this.data.useServerProcessing) {
      return Promise.resolve(this.data.scanImages);
    }
    
    if (this.data.serverImages.length > 0) {
      return Promise.resolve(this.data.serverImages);
    }
    
    this.setData({
      isUploading: true,
      uploadProgress: 0
    });
    
    wx.showLoading({
      title: '正在上传图片...',
    });
    
    console.log('开始验证图片路径');
    const validImages = this._validateImagePaths(this.data.scanImages);
    console.log('有效图片数量:', validImages.length);
    
    // 限制图片数量
    const MAX_IMAGES = 10;
    if (validImages.length > MAX_IMAGES) {
      wx.hideLoading();
      wx.showModal({
        title: '图片数量过多',
        content: `最多只能处理${MAX_IMAGES}张图片，您选择了${validImages.length}张。请删除一些图片后重试。`,
        showCancel: false
      });
      this.setData({
        isUploading: false
      });
      return Promise.reject(new Error(`图片数量超过限制(${MAX_IMAGES})`));
    }
    
    // 检查图片大小
    console.log('开始检查图片大小');
    const fs = wx.getFileSystemManager();
    let totalSize = 0;
    const oversizedImages = [];
    const imageInfos = [];
    
    for (const path of validImages) {
      try {
        console.log('检查图片:', path);
        const stat = fs.statSync(path);
        const sizeInMB = stat.size / (1024 * 1024);
        totalSize += sizeInMB;
        
        imageInfos.push({
          path,
          size: sizeInMB.toFixed(2) + 'MB'
        });
        
        if (sizeInMB > 5) {
          oversizedImages.push({
            path,
            size: sizeInMB.toFixed(2)
          });
        }
      } catch (err) {
        console.error('获取文件信息失败:', path, err);
      }
    }
    
    console.log('图片信息:', imageInfos);
    console.log('总大小:', totalSize.toFixed(2) + 'MB');
    console.log('超大图片数量:', oversizedImages.length);
    
    // 检查是否有过大的图片
    if (oversizedImages.length > 0) {
      wx.hideLoading();
      console.warn('发现过大的图片:', oversizedImages);
      wx.showModal({
        title: '图片过大',
        content: `有${oversizedImages.length}张图片超过5MB，可能无法上传。建议使用本地处理模式。`,
        confirmText: '继续上传',
        cancelText: '使用本地处理',
        success: (res) => {
          if (res.cancel) {
            // 切换到本地处理模式
            this.setData({
              useServerProcessing: false,
              isUploading: false
            });
            wx.showToast({
              title: '已切换到本地处理模式',
              icon: 'none'
            });
          } else if (res.confirm) {
            // 继续上传，但可能会失败
            console.log('用户选择继续上传大图片');
            this._doUploadImages(validImages);
          }
        }
      });
      return Promise.reject(new Error('图片过大，已提示用户'));
    }
    
    // 检查总大小
    if (totalSize > 20) {
      wx.hideLoading();
      console.warn('文件总大小过大:', totalSize.toFixed(2) + 'MB');
      wx.showModal({
        title: '文件总大小过大',
        content: `所有图片总大小为${totalSize.toFixed(2)}MB，超过了20MB的限制。建议使用本地处理模式或减少图片数量。`,
        confirmText: '继续上传',
        cancelText: '使用本地处理',
        success: (res) => {
          if (res.cancel) {
            // 切换到本地处理模式
            this.setData({
              useServerProcessing: false,
              isUploading: false
            });
            wx.showToast({
              title: '已切换到本地处理模式',
              icon: 'none'
            });
          } else if (res.confirm) {
            // 继续上传，但可能会失败
            console.log('用户选择继续上传大文件');
            this._doUploadImages(validImages);
          }
        }
      });
      return Promise.reject(new Error('文件总大小过大，已提示用户'));
    }
    
    console.log('开始执行上传操作');
    return this._doUploadImages(validImages);
  },
  
  // 执行实际的上传操作
  _doUploadImages: function(validImages) {
    console.log('开始执行上传操作，图片数量:', validImages.length);
    const totalImages = validImages.length;
    let uploadedCount = 0;
    let failedCount = 0;
    const serverImages = [];
    const failedImages = [];
    
    // 逐个上传图片
    const uploadPromises = validImages.map((imagePath, index) => {
      console.log(`准备上传第${index + 1}张图片:`, imagePath);
      
      return api.uploadImage(imagePath)
        .then(res => {
          uploadedCount++;
          this.setData({
            uploadProgress: Math.floor((uploadedCount / totalImages) * 100)
          });
          
          console.log(`上传成功 ${uploadedCount}/${totalImages}:`, res);
          
          // 存储服务器返回的图片路径
          if (res.success && res.data && res.data.path) {
            serverImages.push(res.data.path);
            return res.data.path;
          } else {
            console.error('上传成功但返回数据格式不正确:', res);
            failedCount++;
            failedImages.push({
              path: imagePath,
              error: '返回数据格式不正确'
            });
            return null;
          }
        })
        .catch(err => {
          failedCount++;
          console.error(`上传失败 ${failedCount}/${totalImages}:`, err);
          failedImages.push({
            path: imagePath,
            error: err.message || '未知错误'
          });
          
          // 不抛出错误，让其他图片继续上传
          return null;
        });
    });
    
    return Promise.all(uploadPromises)
      .then((results) => {
        wx.hideLoading();
        
        // 过滤掉null值（上传失败的图片）
        const validPaths = results.filter(path => path !== null);
        console.log('上传完成，成功:', uploadedCount - failedCount, '失败:', failedCount);
        console.log('有效的服务器图片路径:', validPaths);
        
        if (failedCount > 0) {
          console.warn('有图片上传失败:', failedImages);
          
          // 如果全部上传失败
          if (failedCount === totalImages) {
            wx.showModal({
              title: '上传失败',
              content: '所有图片上传失败，是否切换到本地处理模式？',
              confirmText: '切换',
              cancelText: '取消',
              success: (res) => {
                if (res.confirm) {
                  this.setData({
                    useServerProcessing: false
                  });
                  wx.showToast({
                    title: '已切换到本地处理模式',
                    icon: 'none'
                  });
                }
              }
            });
            return Promise.reject(new Error('所有图片上传失败'));
          } 
          // 如果部分上传失败
          else {
            wx.showModal({
              title: '部分上传失败',
              content: `共${totalImages}张图片，${failedCount}张上传失败。是否继续处理已上传的图片？`,
              confirmText: '继续处理',
              cancelText: '取消',
              success: (res) => {
                if (!res.confirm) {
                  this.setData({
                    useServerProcessing: false
                  });
                  wx.showToast({
                    title: '已取消处理',
                    icon: 'none'
                  });
                }
              }
            });
          }
        }
        
        this.setData({
          serverImages: validPaths,
          isUploading: false
        });
        
        return validPaths;
      })
      .catch(err => {
        wx.hideLoading();
        this.setData({
          isUploading: false
        });
        console.error('上传过程中发生错误:', err);
        wx.showModal({
          title: '上传失败',
          content: err.message || '未知错误，是否切换到本地处理模式？',
          confirmText: '切换',
          cancelText: '取消',
          success: (res) => {
            if (res.confirm) {
              this.setData({
                useServerProcessing: false
              });
              wx.showToast({
                title: '已切换到本地处理模式',
                icon: 'none'
              });
            }
          }
        });
        throw err;
      });
  },
  
  // 保存为长图
  saveAsLongImage: function() {
    if (this.data.isSaving) return;
    
    this.setData({
      isSaving: true
    });
    
    wx.showLoading({
      title: '正在生成长图...',
    });
    
    // 使用扫描图片路径
    const imagesToSave = this.data.scanImages;
    console.log('准备保存的图片:', imagesToSave);
    
    // 验证图片路径并缓存有效路径，以便后续操作使用
    const validImages = this._validateImagePaths(imagesToSave);
    
    // 缓存有效的图片路径，以便其他保存操作使用
    this.setData({
      validatedImages: validImages
    });
    
    if (validImages.length === 0) {
      wx.hideLoading();
      wx.showToast({
        title: '没有有效的图片',
        icon: 'none'
      });
      this.setData({
        isSaving: false,
        saveOptions: false
      });
      return;
    }
    
    // 检查图片数量
    if (validImages.length > 20) {
      wx.hideLoading();
      wx.showModal({
        title: '图片数量过多',
        content: '图片数量过多，可能导致处理失败或生成的图片过大。建议减少图片数量后重试。',
        showCancel: false,
        success: () => {
          this.setData({
            isSaving: false,
            saveOptions: false
          });
        }
      });
      return;
    }
    
    // 根据是否使用服务器处理选择不同的处理方式
    let processPromise;
    
    if (this.data.useServerProcessing) {
      // 使用服务器处理
      processPromise = this.uploadImages()
        .then(serverImages => {
          if (!serverImages || serverImages.length === 0) {
            throw new Error('上传图片失败');
          }
          
          wx.showLoading({
            title: '正在合并图片...',
          });
          
          return api.mergeImages(serverImages);
        })
        .then(res => {
          // 下载合并后的长图
          wx.showLoading({
            title: '正在下载长图...',
          });
          
          return new Promise((resolve, reject) => {
            const downloadUrl = res.data.fullPath;
            const downloadTask = wx.downloadFile({
              url: downloadUrl,
              success: (res) => {
                if (res.statusCode === 200) {
                  resolve(res.tempFilePath);
                } else {
                  reject(new Error('下载长图失败，状态码：' + res.statusCode));
                }
              },
              fail: (err) => {
                console.error('下载长图失败:', err);
                reject(new Error('下载长图失败: ' + err.errMsg));
              }
            });
            
            // 监听下载进度
            downloadTask.onProgressUpdate((res) => {
              wx.showLoading({
                title: `下载中 ${res.progress}%`,
              });
            });
          });
        })
        .catch(err => {
          console.error('服务器处理失败，尝试本地处理:', err);
          
          // 如果服务器处理失败，尝试本地处理
          wx.showModal({
            title: '服务器处理失败',
            content: '服务器处理失败，是否尝试本地处理？',
            confirmText: '尝试本地处理',
            cancelText: '取消',
            success: (res) => {
              if (res.confirm) {
                // 使用本地处理
                wx.showLoading({
                  title: '正在本地处理...',
                });
                
                ImageProcessor.mergeToLongImage(validImages)
                  .then(longImagePath => {
                    console.log('本地长图生成成功:', longImagePath);
                    // 保存长图到相册
                    return this.saveImageToAlbum(longImagePath);
                  })
                  .then(() => {
                    // 保存文档记录
                    this.saveDocumentRecord();
                    
                    wx.hideLoading();
                    wx.showToast({
                      title: '保存成功',
                      icon: 'success'
                    });
                  })
                  .catch(err => {
                    console.error('本地生成长图失败:', err);
                    wx.hideLoading();
                    wx.showToast({
                      title: '生成长图失败: ' + (err.message || '未知错误'),
                      icon: 'none'
                    });
                  })
                  .finally(() => {
                    this.setData({
                      isSaving: false,
                      saveOptions: false
                    });
                  });
              } else {
                this.setData({
                  isSaving: false,
                  saveOptions: false
                });
                wx.hideLoading();
              }
            }
          });
          
          throw err; // 中断原来的Promise链
        });
    } else {
      // 使用本地处理
      processPromise = ImageProcessor.mergeToLongImage(validImages);
    }
    
    // 只有在使用本地处理或服务器处理成功的情况下才会执行
    if (this.data.useServerProcessing) {
      processPromise
        .then(longImagePath => {
          console.log('长图生成成功:', longImagePath);
          // 保存长图到相册
          return this.saveImageToAlbum(longImagePath).then(() => {
            // 保存文件路径记录
            this.saveFileRecord(longImagePath, 'image');
            return Promise.resolve();
          });
        })
        .then(() => {
          // 保存文档记录
          this.saveDocumentRecord();
          
          wx.hideLoading();
          wx.showToast({
            title: '保存成功',
            icon: 'success'
          });
          
          // 显示查看文件提示
          setTimeout(() => {
            wx.showModal({
              title: '文件已保存',
              content: '您可以在"已保存的文件"页面查看文件路径，或返回首页查看文档记录',
              confirmText: '查看文件',
              cancelText: '返回首页',
              success: (res) => {
                if (res.confirm) {
                  wx.navigateTo({
                    url: '/pages/saved-files/saved-files'
                  });
                } else {
                  // 返回首页
                  this.goToHome();
                }
              }
            });
          }, 1500);
          
          // 重置保存状态，解决第二次保存问题
          this.setData({
            isSaving: false,
            saveOptions: false
          });
        })
        .catch(err => {
          // 错误已在前面处理
          console.log('处理错误:', err);
          
          // 确保重置保存状态
          this.setData({
            isSaving: false,
            saveOptions: false
          });
        });
    } else {
      processPromise
        .then(longImagePath => {
          console.log('长图生成成功:', longImagePath);
          // 保存长图到相册
          return this.saveImageToAlbum(longImagePath);
        })
        .then(() => {
          // 保存文档记录
          this.saveDocumentRecord();
          
          wx.hideLoading();
          wx.showToast({
            title: '保存成功',
            icon: 'success'
          });
          
          // 重置保存状态，解决第二次保存问题
          this.setData({
            isSaving: false,
            saveOptions: false
          });
        })
        .catch(err => {
          console.error('生成长图失败:', err);
          wx.hideLoading();
          wx.showToast({
            title: '生成长图失败: ' + (err.message || '未知错误'),
            icon: 'none'
          });
          
          // 确保重置保存状态
          this.setData({
            isSaving: false,
            saveOptions: false
          });
        });
    }
  },
  
  // 验证图片路径是否有效
  _validateImagePaths: function(imagePaths) {
    if (!imagePaths || imagePaths.length === 0) {
      return [];
    }
    
    const fs = wx.getFileSystemManager();
    const validPaths = [];
    
    for (let i = 0; i < imagePaths.length; i++) {
      try {
        const stat = fs.statSync(imagePaths[i]);
        if (stat && stat.size > 0) {
          validPaths.push(imagePaths[i]);
        } else {
          console.warn('图片文件无效:', imagePaths[i]);
        }
      } catch (err) {
        console.warn('图片文件不存在:', imagePaths[i], err);
      }
    }
    
    return validPaths;
  },
  
  // 保存为PDF
  saveAsPDF: function() {
    if (this.data.isSaving) return;
    
    this.setData({
      isSaving: true
    });
    
    wx.showLoading({
      title: '正在生成PDF...',
    });
    
    // 使用扫描图片路径
    const imagesToSave = this.data.scanImages;
    console.log('准备保存的图片:', imagesToSave);
    
    // 验证图片路径并缓存有效路径，以便后续操作使用
    const validImages = this._validateImagePaths(imagesToSave);
    
    // 缓存有效的图片路径，以便其他保存操作使用
    this.setData({
      validatedImages: validImages
    });
    
    if (validImages.length === 0) {
      wx.hideLoading();
      wx.showToast({
        title: '没有有效的图片',
        icon: 'none'
      });
      this.setData({
        isSaving: false,
        saveOptions: false
      });
      return;
    }
    
    // 检查图片数量
    if (validImages.length > 20) {
      wx.hideLoading();
      wx.showModal({
        title: '图片数量过多',
        content: '图片数量过多，可能导致处理失败或生成的PDF过大。建议减少图片数量后重试。',
        showCancel: false,
        success: () => {
          this.setData({
            isSaving: false,
            saveOptions: false
          });
        }
      });
      return;
    }
    
    // 根据是否使用服务器处理选择不同的处理方式
    let processPromise;
    
    if (this.data.useServerProcessing) {
      // 使用服务器处理
      processPromise = this.uploadImages()
        .then(serverImages => {
          if (!serverImages || serverImages.length === 0) {
            throw new Error('上传图片失败');
          }
          
          wx.showLoading({
            title: '正在生成PDF...',
          });
          
          return api.generatePDF(serverImages, this.data.docTitle);
        })
        .then(res => {
          // 下载生成的PDF
          wx.showLoading({
            title: '正在下载PDF...',
          });
          
          return new Promise((resolve, reject) => {
            const downloadUrl = res.data.fullPath;
            console.log('准备下载PDF:', downloadUrl);
            
            // 确保文件保存目录存在
            const fs = wx.getFileSystemManager();
            const saveDir = `${wx.env.USER_DATA_PATH}/pdf/`;
            try {
              fs.accessSync(saveDir);
            } catch (e) {
              console.log('创建PDF保存目录');
              fs.mkdirSync(saveDir, true);
            }
            
            // 生成保存路径，确保使用.pdf扩展名
            const fileName = `${this.data.docTitle.replace(/[^\w\s]/gi, '')}_${Date.now()}.pdf`;
            const filePath = `${saveDir}${fileName}`;
            
            console.log('PDF将保存到:', filePath);
            
            const downloadTask = wx.downloadFile({
              url: downloadUrl,
              filePath: filePath, // 指定保存路径
              success: (res) => {
                if (res.statusCode === 200) {
                  console.log('PDF下载成功:', res.filePath);
                  resolve(res.filePath);
                } else {
                  console.error('下载PDF失败，状态码:', res.statusCode);
                  reject(new Error('下载PDF失败，状态码：' + res.statusCode));
                }
              },
              fail: (err) => {
                console.error('下载PDF失败:', err);
                reject(new Error('下载PDF失败: ' + err.errMsg));
              }
            });
            
            // 监听下载进度
            downloadTask.onProgressUpdate((res) => {
              wx.showLoading({
                title: `下载中 ${res.progress}%`,
              });
            });
          });
        })
        .catch(err => {
          console.error('服务器处理失败，尝试本地处理:', err);
          
          // 如果服务器处理失败，尝试本地处理
          wx.showModal({
            title: '服务器处理失败',
            content: '服务器处理失败，是否尝试本地处理？',
            confirmText: '尝试本地处理',
            cancelText: '取消',
            success: (res) => {
              if (res.confirm) {
                // 使用本地处理
                wx.showLoading({
                  title: '正在本地处理...',
                });
                
                ImageProcessor.generatePDF(validImages, this.data.docTitle)
                  .then(pdfPath => {
                    console.log('本地PDF生成成功:', pdfPath);
                    
                    // 保存文件路径记录
                    this.saveFileRecord(pdfPath, 'pdf');
                    
                    // PDF生成成功，提示用户
                    wx.hideLoading();
                    wx.showModal({
                      title: '生成成功',
                      content: `PDF已生成，是否打开?`,
                      confirmText: '打开文件',
                      success: (res) => {
                        if (res.confirm) {
                          // 尝试打开文件
                          wx.openDocument({
                            filePath: pdfPath,
                            showMenu: true, // 显示右上角菜单
                            success: () => {
                              console.log('打开文档成功');
                            },
                            fail: (err) => {
                              console.error('打开文档失败:', err);
                              wx.showToast({
                                title: '无法打开PDF文件',
                                icon: 'none'
                              });
                            }
                          });
                        } else {
                          // 如果用户不打开文件，显示查看文件路径的提示
                          wx.showModal({
                            title: '文件已保存',
                            content: '您可以在"已保存的文件"页面查看文件路径',
                            confirmText: '查看文件',
                            cancelText: '知道了',
                            success: (res) => {
                              if (res.confirm) {
                                wx.navigateTo({
                                  url: '/pages/saved-files/saved-files'
                                });
                              }
                            }
                          });
                        }
                      }
                    });
                    
                    // 保存文档记录
                    this.saveDocumentRecord();
                  })
                  .catch(err => {
                    console.error('本地生成PDF失败:', err);
                    wx.hideLoading();
                    wx.showToast({
                      title: '生成PDF失败: ' + (err.message || '未知错误'),
                      icon: 'none'
                    });
                  })
                  .finally(() => {
                    this.setData({
                      isSaving: false,
                      saveOptions: false
                    });
                  });
              } else {
                this.setData({
                  isSaving: false,
                  saveOptions: false
                });
                wx.hideLoading();
              }
            }
          });
          
          throw err; // 中断原来的Promise链
        });
    } else {
      // 使用本地处理
      processPromise = ImageProcessor.generatePDF(validImages, this.data.docTitle);
    }
    
    // 只有在使用本地处理或服务器处理成功的情况下才会执行
    if (this.data.useServerProcessing) {
      processPromise
        .then(pdfPath => {
          console.log('PDF生成成功:', pdfPath);
          
          // 保存文件路径记录
          this.saveFileRecord(pdfPath, 'pdf');
          
          // PDF生成成功，提示用户
          wx.hideLoading();
          wx.showModal({
            title: '生成成功',
            content: `PDF已生成，是否打开?`,
            confirmText: '打开文件',
            cancelText: '返回首页',
            success: (res) => {
              if (res.confirm) {
                // 尝试打开文件
                wx.openDocument({
                  filePath: pdfPath,
                  success: () => {
                    console.log('打开文档成功');
                    // 打开文件后询问是否返回首页
                    setTimeout(() => {
                      wx.showModal({
                        title: '返回首页',
                        content: '是否返回首页查看文档记录？',
                        confirmText: '返回首页',
                        cancelText: '留在当前页',
                        success: (res) => {
                          if (res.confirm) {
                            this.goToHome();
                          }
                        }
                      });
                    }, 1000);
                  },
                  fail: (err) => {
                    console.error('打开文档失败:', err);
                    wx.showToast({
                      title: '无法打开PDF文件',
                      icon: 'none'
                    });
                  }
                });
              } else {
                // 用户选择返回首页
                this.goToHome();
              }
            }
          });
          
          // 保存文档记录
          this.saveDocumentRecord();
          
          // 重置保存状态，解决第二次保存问题
          this.setData({
            isSaving: false,
            saveOptions: false
          });
        })
        .catch(err => {
          // 错误已在前面处理
          console.log('处理错误:', err);
          
          // 确保重置保存状态
          this.setData({
            isSaving: false,
            saveOptions: false
          });
        });
    } else {
      processPromise
        .then(pdfPath => {
          console.log('PDF生成成功:', pdfPath);
          
          // PDF生成成功，提示用户
          wx.hideLoading();
          wx.showModal({
            title: '生成成功',
            content: `PDF已生成，是否打开?`,
            confirmText: '打开文件',
            success: (res) => {
              if (res.confirm) {
                // 尝试打开文件
                wx.openDocument({
                  filePath: pdfPath,
                  success: () => {
                    console.log('打开文档成功');
                  },
                  fail: (err) => {
                    console.error('打开文档失败:', err);
                    wx.showToast({
                      title: '无法打开PDF文件',
                      icon: 'none'
                    });
                  }
                });
              }
            }
          });
          
          // 保存文档记录
          this.saveDocumentRecord();
          
          // 重置保存状态，解决第二次保存问题
          this.setData({
            isSaving: false,
            saveOptions: false
          });
        })
        .catch(err => {
          console.error('生成PDF失败:', err);
          wx.hideLoading();
          wx.showModal({
            title: '生成PDF失败',
            content: err.message || '未知错误',
            showCancel: false
          });
          
          // 确保重置保存状态
          this.setData({
            isSaving: false,
            saveOptions: false
          });
        });
    }
  },
  
  // 保存文件路径记录
  saveFileRecord: function(filePath, fileType) {
    // 获取当前用户的唯一标识
    const userInfo = wx.getStorageSync('userInfo') || {};
    const openId = userInfo.openId || 'default_user';
    
    // 使用用户特定的键名来存储文件记录
    const savedFilesKey = `savedFiles_${openId}`;
    
    // 获取已保存的文件记录
    const savedFiles = wx.getStorageSync(savedFilesKey) || [];
    
    // 创建新的文件记录
    const newFile = {
      path: filePath,
      type: fileType, // 'image' 或 'pdf'
      name: this.data.docTitle + (fileType === 'pdf' ? '.pdf' : '.jpg'),
      time: new Date().toLocaleString(),
      userId: openId // 存储用户ID，确保安全隔离
    };
    
    // 添加到记录中
    savedFiles.unshift(newFile);
    
    // 最多保存50个文件记录
    if (savedFiles.length > 50) {
      savedFiles.splice(50);
    }
    
    // 保存记录
    wx.setStorageSync(savedFilesKey, savedFiles);
    
    console.log('已保存文件记录:', newFile);
  },
  
  // 保存图片到相册
  saveImageToAlbum: function(imagePath) {
    return new Promise((resolve, reject) => {
      console.log('准备保存图片到相册:', imagePath);
      
      // 检查路径是否有效
      if (!imagePath) {
        console.error('图片路径无效');
        reject(new Error('图片路径无效'));
        return;
      }
      
      // 先检查授权状态
      wx.getSetting({
        success: (res) => {
          if (!res.authSetting['scope.writePhotosAlbum']) {
            // 如果没有授权，先请求授权
            wx.authorize({
              scope: 'scope.writePhotosAlbum',
              success: () => {
                // 授权成功后保存图片
                this._doSaveImageToAlbum(imagePath, resolve, reject);
              },
              fail: (err) => {
                console.error('授权失败:', err);
                wx.showModal({
                  title: '提示',
                  content: '需要您授权保存图片到相册',
                  confirmText: '去授权',
                  success: (res) => {
                    if (res.confirm) {
                      wx.openSetting();
                    }
                  }
                });
                reject(err);
              }
            });
          } else {
            // 已经授权，直接保存
            this._doSaveImageToAlbum(imagePath, resolve, reject);
          }
        },
        fail: (err) => {
          console.error('获取授权状态失败:', err);
          reject(err);
        }
      });
    });
  },
  
  // 实际执行保存图片的操作
  _doSaveImageToAlbum: function(imagePath, resolve, reject) {
    wx.saveImageToPhotosAlbum({
      filePath: imagePath,
      success: () => {
        console.log('保存图片成功');
        resolve();
      },
      fail: (err) => {
        console.error('保存图片失败:', err);
        
        wx.showToast({
          title: '保存失败: ' + err.errMsg,
          icon: 'none'
        });
        
        reject(err);
      }
    });
  },
  
  // 保存文档记录
  saveDocumentRecord: function() {
    const recentDocs = wx.getStorageSync('recentDocs') || [];
    
    // 保存文件到本地
    const saveFiles = [];
    const fs = wx.getFileSystemManager();
    const promises = this.data.scanImages.map(tempPath => {
      return new Promise((resolve, reject) => {
        // 创建保存目录
        const saveDir = `${wx.env.USER_DATA_PATH}/saved_docs/`;
        try {
          fs.accessSync(saveDir);
        } catch (e) {
          fs.mkdirSync(saveDir, true);
        }
        
        // 生成唯一文件名
        const fileName = `doc_${Date.now()}_${Math.floor(Math.random() * 10000)}.jpg`;
        const savedPath = `${saveDir}${fileName}`;
        
        // 复制文件而不是使用wx.saveFile
        fs.copyFileSync(tempPath, savedPath);
        saveFiles.push(savedPath);
        resolve();
      });
    });
    
    Promise.all(promises).then(() => {
      // 创建文档记录
      const newDoc = {
        id: Date.now().toString(),
        title: this.data.docTitle,
        createTime: new Date().toLocaleString(),
        pageCount: saveFiles.length,
        images: saveFiles,
        coverImage: saveFiles[0] || ''
      };
      
      // 添加到最近文档
      recentDocs.unshift(newDoc);
      
      // 最多保存20个文档记录
      if (recentDocs.length > 20) {
        const removedDocs = recentDocs.splice(20);
        // 删除多余的文件
        const fs = wx.getFileSystemManager();
        removedDocs.forEach(doc => {
          if (doc.images) {
            doc.images.forEach(imgPath => {
              try {
                fs.unlinkSync(imgPath);
              } catch (err) {
                console.error('删除旧文档文件失败:', err);
              }
            });
          }
        });
      }
      
      wx.setStorageSync('recentDocs', recentDocs);
      console.log('文档记录已保存:', newDoc);
    }).catch(err => {
      console.error('保存文件失败:', err);
    });
  },
  
  // 返回首页
  goToHome: function() {
    // 先保存文档记录，确保返回首页时能看到最新记录
    if (this.data.scanImages && this.data.scanImages.length > 0) {
      this.saveDocumentRecord();
    }
    
    // 使用reLaunch确保完全重新加载首页
    setTimeout(() => {
      wx.reLaunch({
        url: '/pages/index/index'
      });
    }, 300); // 添加短暂延迟，确保记录保存完成
  },
  
  // 查看已保存的文件
  viewSavedFiles: function() {
    wx.navigateTo({
      url: '/pages/saved-files/saved-files'
    });
  },
  
  // 删除当前图片
  deleteCurrentImage: function() {
    const index = this.data.currentIndex;
    const scanImages = this.data.scanImages;
    
    if (scanImages.length <= 1) {
      wx.showToast({
        title: '至少需要保留一张图片',
        icon: 'none'
      });
      return;
    }
    
    // 获取要删除的图片路径
    const imageToDelete = scanImages[index];
    
    // 从数组中删除
    scanImages.splice(index, 1);
    
    // 更新全局数据
    getApp().globalData.scanImages = scanImages;
    
    // 如果有服务器图片，也需要删除对应的服务器图片
    if (this.data.serverImages.length > 0) {
      const serverImages = this.data.serverImages;
      serverImages.splice(index, 1);
      this.setData({
        serverImages: serverImages
      });
    }
    
    // 尝试删除文件
    FileManager.deleteFile(imageToDelete).catch(err => {
      console.error('删除图片文件失败:', err);
    });
    
    this.setData({
      scanImages: scanImages,
      currentIndex: Math.min(index, scanImages.length - 1)
    });
    
    wx.showToast({
      title: '已删除图片',
      icon: 'success'
    });
  }
})
